// 云函数入口文件
const cloud = require('wx-server-sdk')
const axios = require('axios')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command

// 替换为阿里云Qwen-Wan的API密钥和地址
const API_KEY = 'sk-1311d926da2e43cd8d41d45a1d3032c4'
const BASE_URL = 'https://dashscope.aliyuncs.com/api/v1'
const MODEL = 'wanx2.1-t2i-plus' // 高级模型
const GENERATE_URL = `${BASE_URL}/services/aigc/text2image/image-synthesis`

// 云函数入口函数
exports.main = async (event, context) => {
  console.log('接收到的请求参数:', event);
  const { action, params } = event
  const wxContext = cloud.getWXContext()
  const openid = wxContext.OPENID

  try {
    switch (action) {
      case 'generateImage':
        return await generateImage(params, openid)
      case 'getImageResult':
        return await getImageResult(params, openid)
      case 'regenerateImage':
        return await regenerateImage(params, openid)
      default:
        return {
          success: false,
          message: '未知的操作类型'
        }
    }
  } catch (error) {
    console.error('操作失败：', error)
    return {
      success: false,
      message: '操作失败',
      error: error.message
    }
  }
}

/**
 * 生成图片
 * @param {Object} params - 包含生成图片所需的参数
 * @param {string} openid - 用户的openid
 */
async function generateImage(params, openid) {
  console.log('生成图片参数:', params);
  const { prompt, negativePrompt, size = '1024*1024', n = 1 } = params

  if (!prompt) {
    return {
      success: false,
      message: '提示词不能为空'
    }
  }

  let taskResult = null; // 定义变量，避免taskResult未定义错误

  try {
    // 创建任务记录
    const taskRecord = {
      openid,
      prompt,
      negativePrompt,
      size,
      n,
      status: 'PENDING',
      createTime: db.serverDate()
    }

    console.log('创建任务记录:', taskRecord);
    taskResult = await db.collection('imageTasks').add({
      data: taskRecord
    })
    console.log('任务创建成功，ID:', taskResult._id);

    const taskId = taskResult._id

    // 构造请求到阿里云图像生成API的参数
    const requestData = {
      model: MODEL,
      input: {
        prompt: prompt
      },
      parameters: {
        size: size,
        n: n
      }
    }

    // 如果有反向提示词，添加到请求中
    if (negativePrompt) {
      requestData.input.negative_prompt = negativePrompt
    }

    console.log('请求阿里云API参数:', JSON.stringify(requestData));

    try {
      // 发送API请求
      const response = await axios({
        method: 'post',
        url: GENERATE_URL,
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${API_KEY}`,
          'X-DashScope-Async': 'enable'
        },
        data: requestData
      })

      console.log('阿里云API响应:', JSON.stringify(response.data));

      if (response.data && response.data.output) {
        const { task_id, task_status } = response.data.output

        // 更新任务ID和状态
        await db.collection('imageTasks').doc(taskId).update({
          data: {
            aliyunTaskId: task_id,
            status: task_status,
            updateTime: db.serverDate()
          }
        })
        console.log('任务状态更新成功');

        return {
          success: true,
          taskId,
          aliyunTaskId: task_id,
          message: '图片生成请求已提交',
          status: task_status
        }
      } else {
        const errorMsg = '创建任务失败：API返回格式异常';
        console.error(errorMsg, response.data);
        
        // 更新任务状态
        await db.collection('imageTasks').doc(taskId).update({
          data: {
            status: 'FAILED',
            error: errorMsg,
            updateTime: db.serverDate()
          }
        })
        
        throw new Error(errorMsg);
      }
    } catch (apiError) {
      console.error('调用阿里云API失败:', apiError);
      
      // 更新任务状态
      await db.collection('imageTasks').doc(taskId).update({
        data: {
          status: 'FAILED',
          error: apiError.message || '调用图像生成API失败',
          updateTime: db.serverDate()
        }
      })
      
      throw apiError; // 继续抛出错误，由外层处理
    }
  } catch (error) {
    console.error('生成图片失败：', error);
    
    // 如果任务已创建但API请求失败，更新任务状态
    if (taskResult && taskResult._id) {
      try {
        await db.collection('imageTasks').doc(taskResult._id).update({
          data: {
            status: 'FAILED',
            error: error.message || '未知错误',
            updateTime: db.serverDate()
          }
        })
        console.log('任务状态已更新为失败');
      } catch (updateErr) {
        console.error('更新任务状态失败:', updateErr);
      }
    }

    // 提取详细错误信息
    let errorMessage = '生成图片失败';
    if (error.response && error.response.data) {
      errorMessage = error.response.data.message || errorMessage;
    }

    return {
      success: false,
      message: errorMessage,
      error: error.message || '未知错误'
    }
  }
}

/**
 * 获取图片生成结果
 * @param {Object} params - 包含任务ID的参数对象
 * @param {string} openid - 用户的openid
 */
async function getImageResult(params, openid) {
  const { taskId } = params

  if (!taskId) {
    return {
      success: false,
      message: '任务ID不能为空'
    }
  }

  try {
    // 先从数据库获取任务信息
    const taskDoc = await db.collection('imageTasks').doc(taskId).get()
    
    if (!taskDoc.data) {
      return {
        success: false,
        message: '任务不存在'
      }
    }

    const task = taskDoc.data
    
    // 权限检查，除非任务是公开的
    if (task.openid !== openid && !task.isPublic) {
      return {
        success: false,
        message: '无权查看该任务'
      }
    }

    // 如果任务已完成并且有结果，直接返回
    if ((task.status === 'SUCCEEDED' || task.status === 'FAILED') && task.result) {
      return {
        success: task.status === 'SUCCEEDED',
        data: task,
        message: task.status === 'SUCCEEDED' ? '获取成功' : '任务处理失败'
      }
    }

    // 从阿里云API查询任务状态
    const aliyunTaskId = task.aliyunTaskId
    
    if (!aliyunTaskId) {
      return {
        success: false,
        message: '任务ID无效'
      }
    }

    console.log(`查询任务结果：${aliyunTaskId}`)

    const response = await axios({
      method: 'get',
      url: `${BASE_URL}/tasks/${aliyunTaskId}`,
      headers: {
        'Authorization': `Bearer ${API_KEY}`
      }
    })

    console.log('任务查询响应：', JSON.stringify(response.data))

    const result = response.data
    const taskStatus = result.output.task_status
    
    // 更新数据库中的任务状态
    const updateData = {
      status: taskStatus,
      updateTime: db.serverDate()
    }
    
    // 保存结果数据
    updateData.result = result
    
    // 如果任务完成，记录完成时间
    if (taskStatus === 'SUCCEEDED' || taskStatus === 'FAILED') {
      updateData.completeTime = db.serverDate()
    }
    
    await db.collection('imageTasks').doc(taskId).update({
      data: updateData
    })
    
    // 构造返回结果
    const updatedTask = {
      ...task,
      ...updateData
    }
    
    return {
      success: taskStatus === 'SUCCEEDED',
      data: updatedTask,
      message: getStatusMessage(taskStatus)
    }
  } catch (error) {
    console.error('获取任务结果失败：', error)
    
    // 提取详细错误信息
    let errorMessage = '获取任务结果失败'
    if (error.response && error.response.data) {
      errorMessage = error.response.data.message || errorMessage
    }
    
    return {
      success: false,
      message: errorMessage,
      error: error.message
    }
  }
}

/**
 * 重新生成图片
 * @param {Object} params - 包含生成图片所需的参数
 * @param {string} openid - 用户的openid
 */
async function regenerateImage(params, openid) {
  const { taskId, prompt, negativePrompt, size, n } = params

  if (taskId) {
    // 如果提供了任务ID，先获取原有任务
    try {
      const taskDoc = await db.collection('imageTasks').doc(taskId).get()
      
      if (!taskDoc.data) {
        return {
          success: false,
          message: '任务不存在'
        }
      }

      const task = taskDoc.data
      
      // 权限检查
      if (task.openid !== openid) {
        return {
          success: false,
          message: '无权操作该任务'
        }
      }

      // 使用当前参数或原任务参数
      const newParams = {
        prompt: prompt || task.prompt,
        negativePrompt: negativePrompt || task.negativePrompt,
        size: size || task.size,
        n: n || task.n
      }

      // 调用生成函数
      return await generateImage(newParams, openid)
    } catch (error) {
      console.error('重新生成图片失败：', error)
      return {
        success: false,
        message: '重新生成图片失败',
        error: error.message
      }
    }
  } else {
    // 如果没有任务ID，检查是否有必要的参数
    if (!prompt) {
      return {
        success: false,
        message: '重新生成需要提供原始任务ID或新的提示词'
      }
    }
    
    // 使用新参数生成
    return await generateImage(params, openid)
  }
}

/**
 * 获取任务状态对应的消息
 * @param {string} status - 任务状态
 * @returns {string} 状态消息
 */
function getStatusMessage(status) {
  switch (status) {
    case 'PENDING': 
      return '任务排队中';
    case 'RUNNING':
      return '任务处理中';
    case 'SUCCEEDED':
      return '任务执行成功';
    case 'FAILED':
      return '任务执行失败';
    case 'SUSPENDED':
      return '任务已挂起';
    default:
      return '未知状态';
  }
} 